Installation classique

Sur Windows ou Mac, dirigez-vous ici, téléchargez et installez. Sur Linux, ouvrez votre gestionnaire d’application, chercher r-base (Ubuntu, Debian), R-base (openSuse) ou R-core (Fedora) et installez-le (asurez-vous que les librairies suivantes sont aussi installées: gcc, gcc-fortran, gcc-c++ et make), vous aurez peut-être besoin d’installer des librairies supplémentaires pour faire fonctionner certains modules.

Note. Les modules présentés dans ce cours devraient être disponibles sur Linux, Windows et Mac. Ce n’est pas le cas pour tous les modules R. La plupart fonctionnent néanmoins sur Linux, dont les systèmes d’opération (je recommande Ubuntu ou l’une de ses dérivées) sont de bonnes options pour le calcul scientifique.

À cette étape, R devrait fonctionner dans un interprétateur de commande . Si vous lancez R dans un terminal (chercher cmd dans le menu si vous êtes sur Windows), vous obtiendrez quelque chose comme ceci.

Le symbole > indique que R attend que vos instructions. Vous voilà dans un état méditatif devant l’indéchiffrable vide du terminal. Afin de travailler dans un environnement de travail plus convivial, je recommande l’installation de l’interface RStudio, gratuite et open source: téléchargez l’installateur et suivez les intructions. RStudio ressemble à ceci.

En haut à droite se trouve un menu Project (None). Il s’agit d’un menu de vos projets. Je recommande d’utiliser ces projets avec RStudio, qui vous permettront de mieux gérer vos environnements de travail, en particulier en lien avec les chemins vers de vos données, graphiques, etc., que vous pouvez gérer relativement à l’emplacement de votre dossier de projet plutôt qu’à l’emplacement des fichiers sur votre machine.

• En haut à gauche, vous avez vos feuilles de calcul, qui apparaîtront en tant qu’onglets. Je recommande de prendre en main les R notebooks, dans lesquels vous pouvez écrire du texte en format Markdown (dont il sera question plus loin) entre des blocks de code. Ceci vous permet de détailler votre flux de travail.
• En bas à gauche apparait la Console, où vous voyez les commandes envoyées à R ainsi que ses sorties. Si vous travaillez en format notebook, vous n’en aurez probablment pas besoin.
• En haut à droite, les différents onglets indiquent où vous en êtes dans vos calculs. En partoiculier, la liste sous Environment indique les objets qui ont été générés jusqu’alors.
• En bas à droite, on retrouve des onglets de nature variés. Files contient les sous-dossiers et fichiers du dossier de projet. Plots est l’endroit où apparaîtront vos graphiques. Packages contient la liste des modules déjà installés, ainsi qu’un outil de gestion des modules pour leur installation, leur désinstallation et leur mise à jour. Help affiche les fiches d’aide des fonctions (pour obtenir de l’aide sur une fonction dans RStudio, surlignez la fonction dans votre feuille de calcul, puis appuyez sur F1). Enfin, l’onglet Viewer affichera les sorties HTML, en particulier les graphiques intéractifs que vous générerez par exemple avec le module plotly.

R notebooks

Les R notebooks offrent une approche de programmation littéraire, c’est-à-dire que vous écrivez votre code comme vous écrivez une article, une thèse ou une histoire. Cette approche permet de partager plus facilement vos codes, que ce soit avec une équipe de travail ou à la communauté scientifitque pour accompagner un article scientifique en tant que matériel supplémentaire. Lorsque vous créez un notebook (File > New file > R notebook), les instructions de base apparaissent. Ajoutons que pour lancer du code ligne par ligne, vous pouvez surligner le code en question ou placez le curseur sur la ligne à exécuter, puis taper Ctrl + Enter. La sortie de R apparaîtra sous le bloc de code. Dans votre texte, vous pouvez ajouter des équations mathématiques en format Mathjax inspiré du format Latex, par exemple $a = \sum_{i=1}^n x_i^2$ sera affiché comme \(a = \sum_{i=1}^n x_i^2\) (pour aider dans l’édition d’équation, vous pouvez utiliser un éditeur dans les nuages). Pour les titres, les caractères gras, l’insertion d’image, les hyper-liens, les tableaux, etc., référez-vous à la documentation de Markdown.

Si votre environnement de travail était un avion, R serait le moteur et RStudio serait le cockpit!

Installation avec Anaconda

Si vous cherchez une trousse complète d’analyse de données, comprenant R et Python, vous pourrez préférer Anaconda. Une fois installée, vous pourrez isoler une environnement de travail sur R, ou même isoler des environnements de travail particuliers pour vos projets. Une manière conviviale de créer des environnements de travail est de passer par l’interface Anaconda navigator, que vous lancerez soit dans le menu Windows, soit en ligne de commande anaconda-navigator sous Mac et Linux, puis d’installer r-essentials, rstudio et jupyterlab dans l’onglet Environment. Vous pourrez aussi installer RStudio et Jupyter lab via l’onglet Home de Anaconda navigator. Dans l’environnement de base, installez le package nb_conda_kernels pour vous assurer que tous les noyaux (R, Python, etc.) installés dans les environnements de travail soient automatiquement accessibles dans Jupyter.

Jupyter lab est une interface notebook semblable à R notebook. C’est justement sous Jupyter lab qu’est rédigé ce document. À vrai dire, l’utilisation de R en Anaconda n’est pas tout à fait au point, et pourrait poser problème pour l’installation de certains modules. Si vous optez pour cette option, préparez-vous à avoir à bidouiller un peu.

Utilisation de Azure notebooks

Microsoft rend disponible gratuitement un service de notebook en ligne nommé Azure notebooks. Vous y aurez accès avec un compte Exchange (par exemple, votre IDUL de l’Université Laval) ou bien avec un compte Microsoft (Outlook, Skype, Hotmail, etc.). Microsoft Azure fonctionne avec Anaconda, et hérite de certaines difficultés à installer des packages. Avantages majeurs: tout fonctionne dans les nuages, donc (1) vous pouvez obtenir des performances intéressantes même si avec un processeur agé ou bas de gamme et (2) vous n’avez rien à installer sur votre machine. Désavantages majeurs: (1) vous devez être conecté à internet et (2) vous devrez installer vos modules à chaque fois que vous vous connecterez pour débuter une session de calcul. Apparamment, l’option de travail collaboratif sur un même notebook est en cours de développement.

Types de données

Jusqu’à maintenant, nous n’avons utilisé que des nombres entiers (integer ou int) et des nombres réels (numeric ou float64). R inclut d’autres types. La chaîne de caractère (string ou character) contient un ou plusieurs symboles. Elle est définie entre des double-guillemets " " ou des apostrophes ' '. Il n’existe pas de standard sur l’utilisation de l’un ou de l’autre, mais en règle générale, on utilise les apostrophe pour les experssions courtes, contenant un simple mot ou séquence de lettres, et les guillements pour les phrases. Une raison pour cela: les guillemets sont utiles pour insérer des apostrophes dans une chaîne de caractère.

a <- "L'ours"
b <- "polaire"
paste(a, b)

## [1] "L'ours polaire"

On colle a et b avec la fonction paste. Notez que l’objet a a été défini précédemment. Il est possible en R de réassigner une variable, mais cela peut porter à confusion, jusqu’à générer des erreurs de calcul si une variable n’est pas assigné à l’objet auquel on voulait référer.

Combien de caractères contient la chaîne "L'ours polaire"? R sait compter. Demandons-lui.

c <- paste(a, b)
nchar(c)

## [1] 14

Quatorze, c’est bien cela (comptez “L’ours polaire”, en incluant l’espace). Comme paste, nchar est une fonction incluse par défaut dans l’environnement de travail de R: plus précisément, ces fonctions sont incluses dans le module base, inclut par défaut lorsque R est lancé. La fonction est appelée en écrivant nchar(). Mais une fonction de quoi? Des arguments, qui se trouvent entre les parenthèses. Dans ce cas, il y a un seul argument: c.

En calcul scientifique, il est courrant de lancer des requêtes sur si une résultat est vrai ou faux.

a <- 17
a < 10

## [1] FALSE

a > 10

## [1] TRUE

a == 10

## [1] FALSE

a != 10

## [1] TRUE

a == 17

## [1] TRUE

!(a == 17)

## [1] FALSE

Je viens d’introduire un nouveau type de donnée: les données booléennes (boolean, ou logical), qui ne peuvent prendre que deux états - TRUE ou FALSE. En même temps, j’ai utilisé la fonction print parce que dans mon carnet, seule la dernière opération permet d’afficher le résultat. Si l’on veut forcer une sortie, on utilise print. Puis, on a vu plus haut que le symbole = est réservé pour assigner des objets: pour les tests d’égalité, on utilise le double égal, ==, ou != pour la non égalité. Enfin, pour inverser une donnée de type booléenne, on utilise le point d’exclamation !.

Les collections de données

Les exercices précédents ont permis de présenter les types de données offerts par défault sur R qui sont les plus importants pour le calcul scientifique: int (integer, ou nombre entier), numeric (nombre réel), character (string, ou chaîne de caractère) et logical (booléen). D’autres s’ajouterons tout au long du cours, comme les catégories (factor) et les unités de temps (date-heure).

Lorsque l’on procède à des opérations de calcul en science, nous utilisons rarement des valeurs uniques. Nous préférons les organiser et les traiter en collections. Par défaut, R offre quatre types importants de collections: les vecteurs, les matrices, les listes et les tableaux.

espece <- c('Petromyzon marinus', 'Lepisosteus osseus', 'Amia calva', 'Hiodon tergisus')
espece

## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"        
## [4] "Hiodon tergisus"

espece[1]

## [1] "Petromyzon marinus"

espece[2]

## [1] "Lepisosteus osseus"

espece[1:3]

## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"

espece[c(1, 3)]

## [1] "Petromyzon marinus" "Amia calva"

espece[-c(1, 3)]

## [1] "Lepisosteus osseus" "Hiodon tergisus"

espece <- c(espece, "Cyprinus carpio")
espece

## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"        
## [4] "Hiodon tergisus"    "Cyprinus carpio"

espece[3] <- "Lepomis gibbosus"
espece

## [1] "Petromyzon marinus" "Lepisosteus osseus" "Lepomis gibbosus"  
## [4] "Hiodon tergisus"    "Cyprinus carpio"

mat <- matrix(c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), ncol=3)
mat

##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12

colnames(mat) <- c('A', 'B', 'C')
rownames(mat) <- c('site_1', 'site_2', 'site_3', 'site_4')
mat

##        A B  C
## site_1 1 5  9
## site_2 2 6 10
## site_3 3 7 11
## site_4 4 8 12

colnames(mat)

## [1] "A" "B" "C"

rownames(mat)

## [1] "site_1" "site_2" "site_3" "site_4"

ma_liste <- list(especes = c('Petromyzon marinus', 'Lepisosteus osseus', 
                             'Amia calva', 'Hiodon tergisus'),
                 site = 'A101',
                stations_meteos = c('746583', '783786', '856363'))
ma_liste

## $especes
## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"        
## [4] "Hiodon tergisus"   
## 
## $site
## [1] "A101"
## 
## $stations_meteos
## [1] "746583" "783786" "856363"

ma_liste$especes

## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"        
## [4] "Hiodon tergisus"

ma_liste[[1]]

## [1] "Petromyzon marinus" "Lepisosteus osseus" "Amia calva"        
## [4] "Hiodon tergisus"

tableau <- data.frame(espece = c('Petromyzon marinus', 'Lepisosteus osseus', 
                                'Amia calva', 'Hiodon tergisus'),
                     poids = c(10, 13, 21, 4),
                     longueur = c(35, 44, 50, 8))
tableau

tableau[, 2:3]

tableau$poids

## [1] 10 13 21  4

tableau['poids']

Les fonctions

Lorsque vous écrivez une commande suivit de parenthèses, comme data.frame(especes = ...), vous demandez à R de passer à l’action en appelant une fonction. De manière très générale, une fonction transforme quelque chose en quelque chose d’autre.

Par exemple, la fonction mean() prend une collection de nombre comme entrée, puis en sort vous devinez quoi.

mean(tableau$poids)

## [1] 12

Les entrées sont appelés les arguments de la fonction. Leur définition est toujours disponible dans la documentation.

Exercice. Familiarisez-vous avec la documentation de R en lançant ?mean. Truc: si vous avez pris de l’avance et que vous travaillez déjà en RStudio, mettez le terme en surbrillance, puis appuyez sur F1.

Vous verrez dans la documentation que la fonction mean() demande trois arguments, x, trim et na.rm. Or nous avons seulement placé un vecteur, sans spécifier d’argument!

En effet. En l’absence d’une définition des arguments, R supposera que les arguments dans la parenthèse, séparés par une virgule, sont présentés dans le même ordre que celui spécifié dans la définition de la fonction (celle qui est présentée dans le fichier d’aide). Dans le cas qui nous intéresse, mean(tableau$poids) est équivalent à mean(x = tableau$poids).

Maintenant, selon la fiche d’aire l’argument na.rm est un valeur logique spécifiant si oui (TRUE) ou non (FALSE) les valeurs manquantes doivent être considérées (une moyenne d’un vecteur comprenant au moins un NA sera de NA). En ne spécifiant rien, R prend la valeur par défaut, telle que spécifiée dans la documentation. Il en va de même que l’argument trim, qui permet d’élaguer des valeurs extrêmes. Dans la fiche d’aide, mean(x, trim = 0, na.rm = FALSE, ...) signifie que par défaut, l’argument x est vide (il doit donc être spécifié), l’argument trim est de 0 et l’argument na.rm est FALSE.

mean(c(6, 1, 7, 4, 9, NA, 1))

## [1] NA

mean(c(6, 1, 7, 4, 9, NA, 1), na.rm = TRUE)

## [1] 4.666667

Vous n’êtes pas emprisonné par les fonctions offertes par R. Vous pouvez installer des modules qui complètent les fonctions de base de R: on le verra un peu plus loin dans ce chapitre. Mais pour l’instant, voyons comment vous pouvez créer vos propres fonctions. Disons que vous voulez créer une fonction qui calcule la sortie de \(x^3-2y+a\). Pour obtenir la réponse on a besoin des arguments x, y et a. La sortie de la fonction est ici triviale: la réponse de l’équation. L’opération function permet de prendre ça en charge.

operation_f <- function(x, y, a = 10) {
    return(x^3-2*y+a)
}

Notez que a a une valeur par défaut. La sortie de la fonction est ce qui se trouve entre les parenthèses de return. Vous pouvez maintenant utiliser la fonction operation_nl au besoin.

operation_f(x = 2, y = 3, a = 1)

## [1] 3

Une telle fonction est peu utile. Mais l’utilisation de fonctions personnalisées vous permettra d’éviter de répéter la même opération plusieurs fois dans un flux de travail, en évitant de générer trop de code, donc aussi de potentielles erreurs. Personnellement, j’utilise les fonctions surtout pour générer des graphiques personnalisés.

Exercice. Afin d’acquérir de l’autonomie, vous devrez être en mesure de trouver le nom des commandes dont vous avez besoin pour effectuer la tâche que vous désirer effectuer. Cela peut causer des frustrations, mais vous vous sentirez toujours plus à l’aise vec R jour après jour. L’exercice ici est de trouver par vous-même la commande qui vous permettra mesurer la longueur d’un vecteur.

Les boucles

Les boucles permettent d’effectuer une même suite d’opérations sur plusieurs objets. Pour faire suite à notre exemple, nous désirons obtenir le résultat de l’opération f pour des paramètres que nous enregistrons dans ce tableau.

params <- data.frame(x = c(2, 4, 1, 5, 6),
                     y = c(3, 4, 8, 1, 0),
                     a = c(6, 1, 8, 2, 5))
params

Nous créons un vecteur vide, puis nous itérons ligne par ligne en remplissant le vecteur.

operation_res <- c()
for (i in 1:nrow(params)) {
    operation_res[i] <- operation_f(x = params[i, 1], y = params[i, 2], a = params[i, 3])
}
operation_res

## [1]   8  57  -7 125 221

En faisant varier i sur des valeurs du vecteur donné par la séquence de nombre entiers de 1 au nombre de ligne du tableau de paramètres, nous demandons à R d’effectuer la suite d’opération entre les accolades {}. À chaque boucle, i prend une valeur de la séquence. i est utilisé ici comme indice de la ligne à soutirer du tableau params, qui correspond à l’indice dans le vecteur operation_res.

Ainsi, chaque résultat est calculé dans l’ordre des lignes du tableau de paramètres et l’on pourra très bien y coller nos résultats:

params$resultats <- operation_res
params

Notez que puisque la colonne resultat n’existe pas dans le tableau params, R crée automatiquement une nouvelle colonne.

Les boucles for vous permettront par exemple de générer en peu de temps 10, 100, 1000 graphiques (autant que vous voulez), chacun issu de simulations obtenues à partir de conidtions initiales différentes, et de les enregistrer dans un répertoire sur votre ordinateur. Un travail qui pourrait prendre des semaines sur Excel peut être effectué en R en quelques secondes.

Un second outil est disponible pour les itérations: les boucles while. Elles effectue une opération tant qu’un critère n’est pas atteint. Elles sont utiles pour les opérations où l’on cherche une convergence. Je les couvre rapidement puisque’elles sont rarement utilisées dans les flux de travail courrants. En voici un petit exemple.

x <- 100
while (x > 1.1) {
    x <- sqrt(x)
    print(x)
}

## [1] 10
## [1] 3.162278
## [1] 1.778279
## [1] 1.333521
## [1] 1.154782
## [1] 1.074608

Nous avons inité x à une valeur de 100. Puis, tant que (while) le test x > 1.1 est vrai, attribuer à x la nouvelle valeur calculée en extrayant la racine de la valeur précédente de x. Enfin, indiquer la valeur avec print.

Conditions: if, else if, else

Si la condition 1 est remplie, effectuer une suite d’instruction 1. Si la condition 1 n’est pas remplie, et si la condition 2 est remplie, effectuer la suite d’instruction 2. Sinon, effectuer la suite d’instruction 3.

Voilà comment on exprime une suite de conditions. Prenons l’exemple simple d’une discrétisation d’une valeur continue. Si \(x<10\), il est classé comme faible. Si \(10 \leq x <20\), il est classé comme moyen. Si \(x \geq 20\), il est classé comme élevé. Plaçons cette classification dans une fonction.

classification <- function(x, lim1=10, lim2=20)  {
    if (x < lim1) {
        categorie <- "faible"
    } else if (x < lim2) {
        categorie <- "moyen"
    } else {
        categorie <- "élevé"
    }
    return(categorie)
}
classification(-10)

## [1] "faible"

classification(15.4)

## [1] "moyen"

classification(1000)

## [1] "élevé"

Une condition est définie avec le if, suivi du test à vrai ou faux entre parenthèse. Si le test retourne un vrai (TRUE), l’instruction entre accolades est exécutée. Si elle est fausse, on passe au suivant.

Exercice. Explorer les commandes ifelse et cut et réfléchissez à la manière qu’ils pourraient être utilées pour effectuer une discrétisation plus efficacement qu’avec les if et les else.

Installer et charger un module

La plupart des opérations d’ordre général (comme les racines carrées, les tests statistiques, la gestion de matrices et de tableau, les graphiques, etc.) sont accessibles grâce aux modules de base de R, qui sont installés et chargés par défaut lors du démarrage de R. Des équipes de travail ont néanmoins développé plusieurs modules pour répondre à leurs besoins spécialisés, et les ont laissées disponibles au grand public dans des modules que vous pouvez installer d’un dépôt CRAN (le AppStore de R), d’un dépôt Anaconda (le AppStore de Anaconda, si vous utilisez cette plate-forme), d’un dépôt Github (dépôts décentralisés), etc.

RStudio possède un pratique bouton Install qui vous permet d’y inscrire une liste de modules. Le navigateur anaconda offre aussi une interface d’installation. La commande R pour installer un module est install.packages("ggplot2"), si par exemple vous désirez installer ggplot2, le module graphique par excellence en R. C’est la commande que RStudio lancera tout seul si vous lui demandez d’installer ggplot2.

Les modules sont l’équivalent des applications spécialisées que vous installez sur un téléphone mobile. Pour les utiliser, il faut les ouvir.

Généralement, j’ouvre toutes les applications nécessaires à mon flux de travail au tout début de ma feuille de calcul (la prochaine cellule retournera un message d’erreur si les packages ne sont pas installés).

library("tidyverse") # méta-package qui charge entre autres dplyr et ggplot2

## ── Attaching packages ───────────────────────────────────────────────────────────────────────────── tidyverse 1.2.1 ──

## ✔ ggplot2 3.1.0     ✔ purrr   0.2.5
## ✔ tibble  1.4.2     ✔ dplyr   0.7.7
## ✔ tidyr   0.8.2     ✔ stringr 1.3.1
## ✔ readr   1.1.1     ✔ forcats 0.3.0

## ── Conflicts ──────────────────────────────────────────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ dplyr::filter() masks stats::filter()
## ✖ dplyr::lag()    masks stats::lag()

library("vegan")

## Loading required package: permute

## Loading required package: lattice

## This is vegan 2.5-3

library("nlme")

## 
## Attaching package: 'nlme'

## The following object is masked from 'package:dplyr':
## 
##     collapse

Les modules sont installés sur votre ordinateur à un endroit que vous pourrez retrouver avec la commande .libPaths()

Exercice. À partir d’ici jusqu’à la fin du cours, nous utiliserons RStudio. Ouvrez-le et familiarisez-vous avec l’interface! Quelques petits trucs:

• pour lancer une ligne, placez-votre curseur sur la ligne, puis appuyez sur Ctrl+Enter
• pour lancer une partie de code précise, mettez le en surbrillance, puis Ctrl+Enter
• utilisez toujours le gestionnaire de projets, en haut à droite!
• installez le module tidyverse
• lancez data(iris) pour obtenir un tableau d’exercice, puis cliquez sur l’objet dans la fenêtre environnement
• essayer R notebook